﻿using AutoMapper.Configuration; // AutoMapper 配置相关
using AutoMapper.QueryableExtensions; // AutoMapper 的查询扩展，用于 LINQ 投影
using System; // 系统基础库
using System.Collections.Generic; // 集合相关
using System.Linq; // LINQ 相关
using System.Text; // 文本处理相关
using System.Threading.Tasks; // 异步任务相关
using System.Reflection;// 反射相关
// 引入必要的命名空间
using AutoMapper; // AutoMapper 核心库
using JGSY.AutoMapper.MapperExpression; // 自定义的映射表达式（假设存在）
using SourceType; // 源类型命名空间（假设存在--类库）
using TargetType; // 目标类型命名空间（假设存在--类库）
using JGSY.AutoMapperConfigs; // 统一映射配置（假设存在--类库）

namespace JGSY.AutoMapper
{
    class Program
    {
        // AutoMapper 是第三方的包，用于对象到对象的映射
        static void Main(string[] args)
        {
            try
            {
                // 硬编码示例：手动创建源对象和目标对象并赋值
                {
                    var source = new Source()
                    {
                        Id = 1234,
                        Name = "Richard老师",
                        // Age = 33 // 注释掉的属性，演示属性可能不存在的情况
                    };
                    // 传统手动映射方式（已注释）
                    // var dest = new Dest()
                    // {
                    //     Id = source.Id,
                    //     Name = source.Name,
                    //     Age = source.Age
                    // };
                }

                #region AutoMapper初步使用
                {
                    // 基本配置方式1：直接创建映射配置
                    {
                        // var config = new MapperConfiguration(cfg =>
                        // {
                        //     cfg.CreateMap<Source, Dest>(); // 创建 Source 到 Dest 的映射
                        // });
                        // IMapper mapper = new Mapper(config); // 创建映射器
                        // Dest dest = mapper.Map<Source, Dest>(source); // 执行映射
                    }
                    // 基本配置方式2：使用 Profile（已注释）
                    {
                        // var cfg = new MapperConfigurationExpression();
                        // cfg.AddProfile(new OrderProfile()); // 添加自定义的 Profile
                        // var config = new MapperConfiguration(cfg);
                        // IMapper mapper = new Mapper(config);
                        // Dest dest = mapper.Map<Source, Dest>(source);
                    }
                }
                #endregion

                #region AutoMapper投影
                {
                    // 演示 LINQ 投影（已注释）
                    // var query = new List<Source>()
                    // {
                    //     new Source() { Id=123, Name="Eleven", Age=35 },
                    //     new Source() { Id=234, Name="Richard", Age=33 },
                    //     new Source() { Id=345, Name="Cole", Age=25 }
                    // }.AsQueryable();
                    // 
                    // var cfg = new MapperConfigurationExpression();
                    // cfg.CreateMap<Source, Dest>();
                    // var config = new MapperConfiguration(cfg);
                    // IMapper mapper = new Mapper(config); 
                    // var destlist = mapper.ProjectTo<Dest>(query); // 投影到 Dest 集合
                }
                #endregion

                #region 展平
                {
                    // 演示嵌套对象展平（已注释）
                    // Order order = new Order()
                    // {
                    //     Customer = new Customer() { Name = "Ricahrd" }
                    // };
                    // var product = new Product() { Price = 5000, Name = "笔记本" };
                    // order.AddOrderLineItem(product, 10);
                    //
                    // var config = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.CreateMap<Order, OrderDto>(); // 自动展平嵌套属性
                    // });
                    // IMapper mapper = config.CreateMapper();
                    // OrderDto orderDto = mapper.Map<Order, OrderDto>(order);
                }
                #endregion

                #region IncludeMembers
                {
                    // 演示 IncludeMembers（已注释）
                    // IncludeSource includeSource = new IncludeSource()
                    // {
                    //     Name = "Richard",
                    //     InnerSource = new InnerSource() { Name = "InnerSource-Name", Description = "InnerSource-Description" },
                    //     OtherInnerSource = new OtherInnerSource() { Description = "OtherInnerSource-Description", Name = "OtherInnerSource-Name", Title = "OtherInnerSource-Title" }
                    // }; 
                    // var cfg = new MapperConfigurationExpression();
                    // cfg.CreateMap<IncludeSource, IncludeDestination>().IncludeMembers(s => s.InnerSource, y => y.OtherInnerSource);
                    // cfg.CreateMap<InnerSource, IncludeDestination>(MemberList.None);
                    // cfg.CreateMap<OtherInnerSource, IncludeDestination>(MemberList.None); 
                    // var config = new MapperConfiguration(cfg);
                    // IMapper mapper = new Mapper(config); 
                    // IncludeDestination includeDestination = mapper.Map<IncludeSource, IncludeDestination>(includeSource);
                }
                #endregion

                #region 反向映射和展平化
                {
                    // 演示反向映射（已注释）
                    // Order order = new Order()
                    // {
                    //     Customer = new Customer() { Name = "Ricahrd" }
                    // };
                    // var product = new Product() { Price = 5000, Name = "笔记本" };
                    // order.AddOrderLineItem(product, 10);
                    // var config = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.CreateMap<Order, OrderDto>().ReverseMap(); // 启用反向映射
                    // });
                    // IMapper mapper = config.CreateMapper();
                    // OrderDto orderDto = mapper.Map<Order, OrderDto>(order);
                    // orderDto.CustomerName = "朝夕-Richard";
                    // Order Order1 = mapper.Map<OrderDto, Order>(orderDto); // 反向映射回 Order
                }
                #endregion

                #region 配置验证  
                {
                    // 演示配置验证（已注释）
                    // try
                    // {
                    //     // 基本验证
                    //     // var config = new MapperConfiguration(cfg =>
                    //     // {
                    //     //     cfg.CreateMap<ValdateSource, ValdateDestination>().ReverseMap();
                    //     // });
                    //     // config.AssertConfigurationIsValid(); // 验证配置是否有效
                    // }
                    // catch (Exception ex)
                    // {
                    //     Console.WriteLine(ex.Message);
                    //     throw;
                    // }
                    //
                    // {
                    //     // 忽略未映射属性
                    //     var config = new MapperConfiguration(cfg =>
                    //     {
                    //         cfg.CreateMap<ValdateSource, ValdateDestination>().ForMember(p => p.SomeValuefff, opt => opt.Ignore());
                    //     });
                    //     config.AssertConfigurationIsValid();
                    // }
                    //
                    // {
                    //     // 显式映射
                    //     var config = new MapperConfiguration(cfg =>
                    //     {
                    //         cfg.CreateMap<ValdateSource, ValdateDestination>().ForMember(p => p.SomeValuefff, opt => opt.MapFrom(a => a.SomeValue));
                    //     });
                    //     config.AssertConfigurationIsValid();
                    // }
                }
                #endregion

                #region 列表和数组 
                {
                    // 演示集合映射（已注释）
                    // var configuration = new MapperConfiguration(cfg => cfg.CreateMap<Source, Dest>());
                    // Source[] sources = null; // 测试 null 情况
                    // IMapper mapper = configuration.CreateMapper();
                    // IEnumerable<Dest> ienumerableDest = mapper.Map<Source[], IEnumerable<Dest>>(sources);
                    // ICollection<Dest> icollectionDest = mapper.Map<Source[], ICollection<Dest>>(sources);
                    // IList<Dest> ilistDest = mapper.Map<Source[], IList<Dest>>(sources);
                    // List<Dest> listDest = mapper.Map<Source[], List<Dest>>(sources);
                    // Dest[] arrayDest = mapper.Map<Source[], Dest[]>(sources);
                }
                #endregion

                #region 多态元素类型
                {
                    // 演示多态映射（已注释）
                    // var configuration = new MapperConfiguration(c =>
                    // {
                    //     c.CreateMap<ParentSource, ParentDestination>()
                    //          .Include<ChildSource, ChildDestination>(); // 包含子类映射
                    //     c.CreateMap<ChildSource, ChildDestination>();
                    // });
                    // ParentSource[] sources = new[]
                    //     {
                    //         new ParentSource(),
                    //         new ChildSource(),
                    //         new ParentSource()
                    //     };
                    // IMapper mapper = configuration.CreateMapper();
                    // var destinations = mapper.Map<ParentSource[], ParentDestination[]>(sources);
                }
                #endregion

                #region 自定义类型转换
                {
                    // 演示自定义类型转换
                    try
                    {
                        var configuration = new MapperConfiguration(cfg =>
                        {
                            // 字符串转 int
                            cfg.CreateMap<string, int>().ConvertUsing(s => Convert.ToInt32(s));
                            // 字符串转 DateTime（使用自定义转换器）
                            cfg.CreateMap<string, DateTime>().ConvertUsing(new DateTimeTypeConverter());
                            // 字符串转 Type（使用泛型转换器）
                            cfg.CreateMap<string, Type>().ConvertUsing<TypeTypeConverter>();
                            // 自定义对象映射
                            cfg.CreateMap<CustomSource, CustomDestination>();
                        });
                        configuration.AssertConfigurationIsValid(); // 验证配置
                        var source = new CustomSource
                        {
                            Value1 = "5", // 字符串
                            Value2 = "01/01/2000", // 字符串日期
                            Value3 = "AutoMapperSamples.GlobalTypeConverters.GlobalTypeConverters+Destination" // 类型名称
                        };
                        IMapper mapper = configuration.CreateMapper();
                        CustomDestination result = mapper.Map<CustomSource, CustomDestination>(source);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                        throw;
                    }
                }
                #endregion

                #region 定制值解析器
                {
                    // 演示自定义值解析器（已注释）
                    // {
                    //     var configuration = new MapperConfiguration(cfg =>
                    //     {
                    //         // 直接指定计算表达式
                    //         // cfg.CreateMap<AnalysisResource, AnalysisDestination>().ForMember(p => p.Total, opt => opt.MapFrom(a => a.Value1 + a.Value2));
                    //         
                    //         // 使用自定义解析器类
                    //         cfg.CreateMap<AnalysisResource, AnalysisDestination>().ForMember(p => p.Total, opt => opt.MapFrom<CustomResolver>());
                    //         
                    //         // 使用自定义解析器实例
                    //         cfg.CreateMap<AnalysisResource, AnalysisDestination>().ForMember(p => p.Total, opt => opt.MapFrom(new CustomResolver()));
                    //     });
                    //     configuration.AssertConfigurationIsValid();
                    //     var source = new AnalysisResource { Value1 = 12, Value2 = 23 };
                    //     IMapper mapper = configuration.CreateMapper();
                    //     AnalysisDestination result = mapper.Map<AnalysisResource, AnalysisDestination>(source);
                    // }
                }
                #endregion

                #region 值转换器 
                {
                    // 演示值转换器（已注释）
                    // var configuration = new MapperConfiguration(cfg =>
                    // {
                    //     // 基本字符串格式化
                    //     cfg.CreateMap<ValueOrder, ValueOrderDto>()
                    //         .ForMember(d => d.StrAmount, opt => opt.MapFrom(p => p.Amount.ToString()));
                    //     
                    //     // 使用自定义转换器
                    //     cfg.CreateMap<ValueOrder, ValueOrderDto>()
                    //         .ForMember(d => d.StrAmount, opt => opt.ConvertUsing(new CurrencyFormatter(), src => src.Amount));
                    //     
                    //     // 全局值转换器（已注释）
                    //     // cfg.ValueTransformers.Add<string>(val => val + "万元");
                    //     
                    //     // 嵌套对象映射
                    //     cfg.CreateMap<ValueOrderLineItem, OrderLineItemDto>()
                    //       .ForMember(d => d.StrPrice, opt => opt.MapFrom(p => p.Price.ToString()));
                    // });
                    // configuration.AssertConfigurationIsValid(); 
                    // IMapper mapper = configuration.CreateMapper();
                    // ValueOrder valueOrder = new ValueOrder()
                    // {
                    //     Amount = 10000,
                    //     ValueOrderLineItem = new ValueOrderLineItem()
                    //     {
                    //         Id = 123,
                    //         Name = ".Net高级班的Vip课程",
                    //         Price = 8888
                    //     }
                    // };
                    // ValueOrderDto orderLineItemDto = mapper.Map<ValueOrder, ValueOrderDto>(valueOrder);
                }
                #endregion

                #region Map Action之前和之后 
                {
                    // 演示映射前后的操作（已注释）
                    // var configuration = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.CreateMap<ValueOrder, ValueOrderDto>()
                    //         .ForMember(d => d.StrAmount, opt => opt.MapFrom(p => p.Amount.ToString()))
                    //         .ForMember(des => des.Description, opt => opt.NullSubstitute("如果为空就展示为 Test"))
                    //         .BeforeMap((src, opt) => src.Amount = src.Amount + 1000) // 映射前操作
                    //         .AfterMap((src, opt) => { src.Amount = src.Amount + 1000; }); // 映射后操作
                    //     cfg.ValueTransformers.Add<string>(val => val + "万元");
                    //     cfg.CreateMap<ValueOrderLineItem, OrderLineItemDto>()
                    //       .ForMember(d => d.StrPrice, opt => opt.MapFrom(p => p.Price.ToString()));
                    // });
                    // configuration.AssertConfigurationIsValid();
                    //
                    // IMapper mapper = configuration.CreateMapper();
                    // ValueOrder valueOrder = new ValueOrder()
                    // {
                    //     Amount = 10000,
                    //     ValueOrderLineItem = new ValueOrderLineItem()
                    //     {
                    //         Id = 123,
                    //         Name = ".Net高级班的Vip课程",
                    //         Price = 8888
                    //     }
                    // };
                    // ValueOrderDto orderLineItemDto = mapper.Map<ValueOrder, ValueOrderDto>(valueOrder);
                }
                #endregion

                #region IMappingAction 
                {
                    // 演示 IMappingAction 接口（已注释）
                    // var configuration = new MapperConfiguration(cfg =>
                    // {
                    //     // 直接使用 Lambda
                    //     // cfg.CreateMap<SomePersonObject, SomeOtherPersonObject>()
                    //     //     .BeforeMap((src, opt) => src.Name = src.Name + "---测试")
                    //     //     .AfterMap((src, opt) => src.Name = src.Name + "---测试");
                    //     
                    //     // 使用 IMappingAction 实现类
                    //     cfg.CreateMap<SomePersonObject, SomeOtherPersonObject>()
                    //           .BeforeMap<NameMeJohnAction>()
                    //           .AfterMap<NameMeJohnAction>(); 
                    // });
                    // configuration.AssertConfigurationIsValid();
                    // IMapper mapper = configuration.CreateMapper();
                    // SomePersonObject somePersonObject = new SomePersonObject() { Id = 123, Name = "朝夕教育" };
                    // SomeOtherPersonObject someOtherPersonObject = mapper.Map<SomePersonObject, SomeOtherPersonObject>(somePersonObject);
                }
                #endregion

                #region 映射继承
                {
                    // 演示映射继承（已注释）
                    // var configuration = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.CreateMap<OrderMaster, OrderDtoMaster>()
                    //      .Include<OnlineOrder, OnlineOrderDto>() // 包含子类映射
                    //      .Include<MailOrder, MailOrderDto>();
                    //     cfg.CreateMap<OnlineOrder, OnlineOrderDto>();
                    //     cfg.CreateMap<MailOrder, MailOrderDto>();
                    // });
                    // configuration.AssertConfigurationIsValid();
                    // OrderMaster order = new OnlineOrder() { Id = 1234, Name = "测试数据" };
                    // IMapper mapper = new Mapper(configuration);
                    // var mapped = mapper.Map(order, order.GetType(), typeof(OrderDtoMaster)); 
                    // OrderMaster order1 = new MailOrder() { Id = 2345, Name = "测试数据1" };
                    // var mapped1 = mapper.Map(order1, order1.GetType(), typeof(OrderDtoMaster));
                }
                #endregion

                #region 字符串转换
                {
                    // 演示枚举与字符串自动转换（已注释）
                    // var configuration = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.CreateMap<CustomOrder, CustomOrderDto>(); // 自动处理枚举到字符串的转换
                    // });
                    // configuration.AssertConfigurationIsValid();
                    //
                    // var orderList = new List<CustomOrder>() {
                    //    new CustomOrder(){ OrderType=OrderTypeEnum.FirstOrder },
                    //    new CustomOrder(){ OrderType=OrderTypeEnum.SecondOrder }
                    // }.AsQueryable();
                    //
                    // var strFirstOrder = OrderTypeEnum.FirstOrder.ToString();
                    // var strSecondOrder = OrderTypeEnum.SecondOrder.ToString();
                    // var orderDtoList = orderList.ProjectTo<CustomOrderDto>(configuration).ToList();
                }
                #endregion

                #region 配置 
                {
                    // 演示配置加载方式（已注释）
                    // 动态加载程序集中的映射配置
                    // var myAssembly = Assembly.Load("AutoMapperConfig");
                    // var config = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.AddMaps(myAssembly); // 从程序集加载
                    // });
                    //
                    // var config = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.AddMaps(new[] { "AutoMapperConfig" }); // 从命名空间加载
                    // });
                    //
                    // 从类型加载配置
                    var config = new MapperConfiguration(cfg =>
                    {
                        cfg.AddMaps(new[] { typeof(AutoMapperConfig) });
                    });

                    IMapper mapper = new Mapper(config);
                    CustomOrder customOrder = new CustomOrder() { OrderType = OrderTypeEnum.FirstOrder };
                    CustomOrderDto customOrderDto = mapper.Map<CustomOrder, CustomOrderDto>(customOrder);
                }
                #endregion

                #region 更换字符
                {
                    // 演示成员名称替换（已注释）
                    // var config = new MapperConfiguration(cfg =>
                    // {
                    //    cfg.ReplaceMemberName("Description", "Test"); // 将 Description 替换为 Test
                    //    cfg.CreateMap<CustomOrder, CustomOrderDto>();
                    // });
                    //
                    // IMapper mapper = new Mapper(config);
                    // CustomOrder customOrder = new CustomOrder()
                    // {
                    //     OrderType = OrderTypeEnum.FirstOrder,
                    //     Description = "更换字符"
                    // };
                    // CustomOrderDto customOrderDto = mapper.Map<CustomOrder, CustomOrderDto>(customOrder);
                }
                #endregion

                #region 识别前后缀
                {
                    // 演示前后缀识别（已注释）
                    // var config = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.ClearPrefixes(); // 清除默认前缀
                    //     cfg.RecognizePrefixes("Zhaoxi"); // 识别 Zhaoxi 前缀
                    //     cfg.CreateMap<CustomOrder, CustomOrderDto>();
                    // });
                    //
                    // IMapper mapper = new Mapper(config);
                    // CustomOrder customOrder = new CustomOrder()
                    // {
                    //     OrderType = OrderTypeEnum.FirstOrder,
                    //     Description = "更换字符",
                    //     ZhaoxiPrefix = "识别前后缀"
                    // };
                    // CustomOrderDto customOrderDto = mapper.Map<CustomOrder, CustomOrderDto>(customOrder);
                }
                #endregion

                #region 特性映射
                {
                    // 演示基于特性的映射（已注释）
                    // {
                    //     // 基本配置
                    //     var config = new MapperConfiguration(cfg =>
                    //     {
                    //         cfg.CreateMap<CustomOrder, CustomOrderDto>();
                    //     });
                    //     IMapper mapper = new Mapper(config);
                    //     CustomOrder customOrder = new CustomOrder()
                    //     {
                    //         OrderType = OrderTypeEnum.FirstOrder,
                    //         Description = "描述信息"
                    //     };
                    //     CustomOrderDto customOrderDto = mapper.Map<CustomOrder, CustomOrderDto>(customOrder);
                    // }
                    // 
                    // { // 使用特性映射
                    //     var config = new MapperConfiguration(cfg =>
                    //     {
                    //         cfg.AddMaps(typeof(CustomOrderDto)); // 从特性加载配置
                    //     });
                    //
                    //     IMapper mapper = new Mapper(config);
                    //     CustomOrder customOrder = new CustomOrder()
                    //     {
                    //         OrderType = OrderTypeEnum.FirstOrder,
                    //         Remark = "描述信息",
                    //         Prefix = "Prefix"
                    //     };
                    //     CustomOrderDto customOrderDto = mapper.Map<CustomOrder, CustomOrderDto>(customOrder);
                    // }
                }
                #endregion

                #region 条件映射
                {
                    // 演示条件映射（已注释）
                    // var config = new MapperConfiguration(cfg =>
                    // {
                    //     cfg.CreateMap<CustomOrder, CustomOrderDto>()
                    //     .ForMember(d => d.Description, opt => opt.Condition(a => a.Description.Contains("条件映射"))) // 条件：包含"条件映射"
                    //     .ForMember(d => d.Id, opt => opt.Condition(a => a.Id > 10)); // 条件：Id > 10
                    // });
                    // IMapper mapper = new Mapper(config);
                    // CustomOrder customOrder = new CustomOrder()
                    // {
                    //     OrderType = OrderTypeEnum.FirstOrder,
                    //     Description = "条件映射",
                    //     Id = 11
                    // };
                    // CustomOrderDto customOrderDto = mapper.Map<CustomOrder, CustomOrderDto>(customOrder);
                }
                #endregion

                #region 泛型映射 
                {
                    // 演示泛型类型映射
                    var config = new MapperConfiguration(cfg =>
                    {
                        cfg.CreateMap(typeof(GenericResult<>), typeof(GenericResultDto<>)); // 泛型映射
                    });
                    IMapper mapper = new Mapper(config);
                    GenericResult<CustomOrder> genericResult = new GenericResult<CustomOrder>()
                    {
                        Value = new CustomOrder()
                        {
                            OrderType = OrderTypeEnum.FirstOrder,
                            Description = "泛型映射",
                            Id = 11,
                            Prefix = "Prefix"
                        }
                    };
                    GenericResultDto<CustomOrder> customOrderDto = mapper.Map<GenericResult<CustomOrder>, GenericResultDto<CustomOrder>>(genericResult);
                }
                #endregion

                Console.Read(); // 等待用户输入，防止控制台关闭
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message); // 输出异常信息
                throw; // 重新抛出异常
            }
        }
    }
}